package com.xp.gather2.comment.utils;

import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.ParsePosition;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

/**
 * 日期类
 *
 * @author Administrator
 *
 */
public class DateUtils {

	private static final String DEFAULT_PATTERN = "yyyy-MM-dd HH:mm:ss";
	private static final String DEFAULT_PATTERN24 = "yyyy-MM-dd HH:mm:ss";
	private static final SimpleDateFormat DEFAULT_FORMAT = new SimpleDateFormat(DEFAULT_PATTERN);

	public static boolean isDate(String value,String format){

		SimpleDateFormat sdf = null;
		ParsePosition pos = new ParsePosition(0);//指定从所传字符串的首位开始解析

		if(StringUtils.isBlank(value)|| StringUtils.isBlank(format)){
			return false;
		}
		try {
			sdf = new SimpleDateFormat(format);
			sdf.setLenient(false);
			Date date = sdf.parse(value,pos);
			if(date == null){
				return false;
			}else{
				//更为严谨的日期,如2011-03-024认为是不合法的
				if(pos.getIndex() > sdf.format(date).length()){
					return false;
				}
				return true;
			}
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}

	/**
	 *  有效期截止时间 距离有效期年限几天
	 * @param newData 有效期开始时间
	 * @param year  有效期年限
	 * @param endTime   有效期截止时间
	 * @return 天
	 */
	public static Long  checkCredTime(Date newData,int year,String endTime){
		SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
		Date endData = null;
		String startTime = sdf.format(newData);
		String yyyy = startTime.substring(0, 4);
		String MMdd = startTime.substring(4, 8);
		int yyyynt = Integer.parseInt(yyyy);
		yyyynt = yyyynt+year;
		startTime = yyyynt+MMdd;
		Date dataTime = null;
		try {
			endData = sdf.parse(endTime);
			dataTime = sdf.parse(startTime);
		} catch (ParseException e) {
			e.printStackTrace();
		}
		long between =  (endData.getTime()-dataTime.getTime())/86400000;
		return between;
	}
	/**
	 * 取得当前系统日期
	 *
	 * @return
	 */
	public static Date getCurrentDate() {
		return Calendar.getInstance().getTime();
	}

	/**
	 * 取得指定日期
	 *
	 * @param date
	 * @return
	 */
	public static Date getDate(String date) {

		try {
			return DEFAULT_FORMAT.parse(date);
		} catch (ParseException e) {
			e.printStackTrace();
			return null;
		}
	}

	/**
	 * 取得当前日期某日历字段的值
	 *
	 * @param field
	 * @return
	 */
	public static int getCurrentDateField(int field) {
		Calendar calendar = Calendar.getInstance();
		return calendar.get(field);
	}

	/**
	 * 取得当前系统日期，并根据日历的规则，为给定的日历字段添加或减去指定的时间量
	 *
	 * @param field
	 * @param amount
	 * @return
	 */
	public static Date getCurrentDate(int field, int amount) {
		Calendar calendar = Calendar.getInstance();

		calendar.add(field, amount);
		return calendar.getTime();
	}

	/**
	 * 取得按默认格式格式化后的当前系统日期
	 *
	 * @return
	 */
	public static String getCurrentDateFormat() {
		return new SimpleDateFormat(DEFAULT_PATTERN).format(getCurrentDate());
	}

	/**
	 * 取得按默认格式格式化后的当前系统日期
	 *
	 * @return
	 */
	public static String getCurrentDateFormat24() {
		return new SimpleDateFormat(DEFAULT_PATTERN24).format(getCurrentDate());
	}
	/**
	 * 取得格式化后的当前系统日期
	 *
	 * @param pattern
	 * @return
	 */
	public static String getCurrentDateFormat(String pattern) {
		return new SimpleDateFormat(pattern).format(getCurrentDate());
	}

	/**
	 * 将指定的日期格式化.
	 *
	 * @param date
	 * @param pattern
	 * @return
	 * @throws ParseException
	 * @author bulang
	 */
	public static String formatDate(Date date, String pattern) throws ParseException {
		return new SimpleDateFormat(pattern).format(date);
	}

	/**
	 * 将默认格式的日期字符串格式化为指定格式， 默认格式为yyyy-MM-dd
	 *
	 * @param date
	 * @param pattern
	 * @return
	 */
	public static String formatDate(Object date, String pattern) throws ParseException {
		Date d = DEFAULT_FORMAT.parse(ObjectUtils.toString(date));

		return new SimpleDateFormat(pattern).format(d);
	}

	/**
	 * 将格式1的日期字符串格式化为指定格式2
	 *
	 * @param date
	 * @param pattern1
	 * @param pattern2
	 * @return
	 */
	public static String formatDate(Object date, String pattern1, String pattern2) throws ParseException {
		Date d = new SimpleDateFormat(pattern1).parse(ObjectUtils.toString(date));

		return new SimpleDateFormat(pattern2).format(d);
	}

	/**
	 * 取得格式化后的当前系统日期，并根据日历的规则，为给定的日历字段添加或减去指定的时间量
	 *
	 * @param pattern
	 * @return
	 */
	public static String getODateFormat(Date date,String pattern, int field, int amount) {
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(field, amount);
		return new SimpleDateFormat(pattern).format(calendar.getTime());
	}
	/**
	 * 取得指定日期，并根据日历的规则，为给定的日历字段添加或减去指定的时间量
	 *
	 * @param pattern
	 * @return
	 */
	public static String getCurrentDateFormat(String pattern, int field, int amount) {
		return new SimpleDateFormat(pattern).format(getCurrentDate(field, amount));
	}

	/**
	 * 取得格式化后的当前系统日期，并根据日历的规则，为给定的日历字段添加或减去指定的时间量 默认的日历字段：月份 默认的日期格式：yyyy-MM-dd
	 *
	 * @param amount
	 * @return
	 */
	public static String getCurrentDateFormat(int amount) {
		return new SimpleDateFormat(DEFAULT_PATTERN).format(getCurrentDate(Calendar.MONTH, amount));
	}

	/**
	 * 取得上个月的指定格式日期字符串
	 *
	 * @param pattern
	 *            指定日期格式
	 * @return
	 */
	public static String getPrevMonth(String pattern) {
		return getCurrentDateFormat(pattern, Calendar.MONTH, -1);
	}

	/**
	 * 取得指定的日期的每一天
	 *
	 * @param date
	 * @param pattern
	 * @return
	 * @throws ParseException
	 */
	public static String getStartDate(Object date, String pattern) throws ParseException {
		Date d = new SimpleDateFormat(pattern).parse(ObjectUtils.toString(date));
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(d);
		calendar.set(Calendar.DAY_OF_MONTH, 1);
		return DEFAULT_FORMAT.format(calendar.getTime());
	}

	/**
	 * 取得当前系统日期的格式化显示，显示格式如 2009年07月17日 星期五
	 *
	 * @return
	 * @throws ParseException
	 */
	public static String getDateView() throws ParseException {
		return new SimpleDateFormat("yyyy年MM月dd日 E").format(getCurrentDate());
	}

	/**
	 * 取得指定日期的格式化显示，显示格式如 2009年07月17日 星期五
	 *
	 * @param date
	 * @return
	 * @throws ParseException
	 */
	public static String getDateView(String date) throws ParseException {
		return getDateView(DEFAULT_PATTERN, date);
	}

	/**
	 * 取得指定日期的格式化显示，显示格式如 2009年07月17日 星期五
	 *
	 * @param pattern
	 *            指定日期格式
	 * @param date
	 *            指定日期
	 * @return
	 * @throws ParseException
	 */
	public static String getDateView(String pattern, String date) throws ParseException {
		return getDateView(pattern, date, "yyyy年MM月dd日 E");
	}

	/**
	 * 取得指定日期的格式化显示
	 *
	 * @param pattern
	 *            指定日期格式
	 * @param date
	 *            指定日期
	 * @param pattern2
	 *            显示格式
	 * @return
	 * @throws ParseException
	 */
	public static String getDateView(String pattern, String date, String pattern2) throws ParseException {
		Date d = new SimpleDateFormat(pattern).parse(ObjectUtils.toString(date));
		String s = new SimpleDateFormat(pattern2).format(d);
		return s;
	}

	/**
	 * 获取两个日期相减得到的天数
	 *
	 * @param beginDate
	 *            开始日期
	 * @param endDate
	 *            结束日期
	 * @return
	 * @throws Exception
	 */
	public static int getSubtractDate(String beginDate, String endDate) throws Exception {

		Calendar calendar1 = Calendar.getInstance();
		Calendar calendar2 = Calendar.getInstance();

		calendar1.setTime(DEFAULT_FORMAT.parse(beginDate));
		calendar2.setTime(DEFAULT_FORMAT.parse(endDate));

		return (int) ((calendar2.getTimeInMillis() - calendar1.getTimeInMillis()) / 1000 / 60 / 60 / 24);// 结果
	}

	/**
	 * 取得指定日期本周日的日期.
	 *
	 * @param date
	 * @return
	 * @throws Exception
	 * @author bulang
	 */
	public static String getLastDayOfWeek(String date) throws Exception {
		Date d = new SimpleDateFormat(DEFAULT_PATTERN).parse(ObjectUtils.toString(date));
		Calendar calendar = Calendar.getInstance();
		calendar.setFirstDayOfWeek(Calendar.MONDAY);
		calendar.setTime(d);

		calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY);

		return DEFAULT_FORMAT.format(calendar.getTime());
	}

	/**
	 * 取得指定日期是当年第几周.
	 *
	 * @param date
	 * @return
	 * @throws Exception
	 * @author bulang
	 */
	public static int getWeekOfYear(String date) throws Exception {
		Date d = new SimpleDateFormat(DEFAULT_PATTERN).parse(ObjectUtils.toString(date));
		Calendar calendar = Calendar.getInstance();
		calendar.setFirstDayOfWeek(Calendar.MONDAY);
		calendar.setTime(d);
		return calendar.get(Calendar.WEEK_OF_YEAR);
	}

	public static void main(String[] args) throws Exception {
		// System.err.println(getSubtractDate("2005-05-05","2009-07-17"));
		// System.out.println(getCurrentDateFormat("yyyyMMddHHmmssSSSSSS"));
		// System.out.println(getLastDayOfWeek("2014-05-15"));
		// System.out.println(getWeekOfYear("2014-05-15"));
		// System.out.println(TimeZone.getDefault().getID() );
		// TimeZone tz =TimeZone.getTimeZone("Asia/Shanghai");
		// TimeZone.setDefault(tz);
	System.out.println(	getDistanceDays("20161220","20161222"));
	}

	/**
	 * 根据时间和时间格式返回时间戳
	 */
	public static Long dateToStamp(String s ,  String format) throws ParseException{
		SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
		Date date = simpleDateFormat.parse(s);
		return  date.getTime();
	}
	/***
	 * 时间戳转日期字符串
	 *
	 * @param seconds
	 * @param format
	 * @return
	 * @author zhougq
	 */
	public static String timeStamp2Date(String seconds, String format) {
		if (seconds == null || seconds.isEmpty() || seconds.equals("null")) {
			return "";
		}
		if (format == null || format.isEmpty())
			format = DEFAULT_PATTERN;
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(new Date(Long.valueOf(seconds + "000")));
	}

	/**
	 * 获取截止到当前系统时间月份集合.
	 * 比如：当前时间：2016-08-08；则返回:[2016-01,2016-02,2016-03,....,2016-08]
	 *
	 * @param
	 * @return
	 * @throws Exception
	 * @author daisuhai
	 */
	public static List<String> getMonthOfYear() throws Exception {
		ArrayList<String> list = new ArrayList<String>();
		Date d1 = new SimpleDateFormat("yyyy-MM").parse(getCurrentDateFormat().substring(0, 4)+"-01");// 定义起始日期
		Date d2 = getCurrentDate();// 定义结束日期
		Calendar dd = Calendar.getInstance();// 定义日期实例
		dd.setTime(d1);// 设置日期起始时间
		while (dd.getTime().before(d2)) {// 判断是否到结束日期
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
			String str = sdf.format(dd.getTime());
			dd.add(Calendar.MONTH, 1);// 进行当前日期月份加1
			list.add(str);
		}
		return list;
	}
	/***
	 * 获取前一天
	 * @return
	 * @author zhougq
	 */
	public static Date getYestaday(){
		Date date=new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		date = calendar.getTime();
		return date;
	}
	/***
	 * 按照指定格式获取前一天
	 * @param pattern
	 * @return
	 */
	public static String getYestadayDateFormat(String pattern){
		Date date=new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, -1);
		date = calendar.getTime();
		return new SimpleDateFormat(pattern).format(date);
	}
	/***
	 * 按照指定格式获取前n天
	 * @param pattern
	 * @return
	 */
	public static String getPastDateFormat(String pattern,int n){
		Date date=new Date();
		Calendar calendar = Calendar.getInstance();
		calendar.setTime(date);
		calendar.add(Calendar.DAY_OF_MONTH, -n);
		date = calendar.getTime();
		return new SimpleDateFormat(pattern).format(date);
	}
	/***
	 * 获取前一个月天数
	 * @return
	 * @author zhougq
	 */
	public static int getPreDayOfMonth(){
		Calendar calendar = Calendar.getInstance();
		calendar.add(Calendar.MONTH, -1);

		return calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
	}

	/***
	 *
	 * @param DATE1
	 * @param DATE2
	 * @param pattern
	 * @return
	 */
	 public static int compareDate(String DATE1, String DATE2,String pattern) {


	        DateFormat df = new SimpleDateFormat(pattern);
	        try {
	            Date dt1 = df.parse(DATE1);
	            Date dt2 = df.parse(DATE2);
	            if (dt1.getTime() < dt2.getTime()) {
	                System.out.println("dt1 在dt2前");
	                return 1;
	            } else if (dt1.getTime() > dt2.getTime()) {
	                System.out.println("dt1在dt2后");
	                return -1;
	            } else {
	                return 0;
	            }
	        } catch (Exception exception) {
	            exception.printStackTrace();
	        }
	        return 0;
	    }
	 /**
	     * 两个时间之间相差距离多少天  格式yyyyMMdd
	     * @param： one 时间参数 1：
	     * @param： two 时间参数 2：
	     * @return 相差天数
	     */
	    public static long getDistanceDays(String str1, String str2) throws Exception{
	        DateFormat df = new SimpleDateFormat("yyyyMMdd");
	        Date one;
	        Date two;
	        long days=0;
	        try {
	            one = df.parse(str1);
	            two = df.parse(str2);
	            long time1 = one.getTime();
	            long time2 = two.getTime();
	            long diff ;
	            if(time1<time2) {
	                diff = time2 - time1;
	            } else {
	                diff = time1 - time2;
	            }
	            days = diff / (1000 * 60 * 60 * 24);
	        } catch (ParseException e) {
	            e.printStackTrace();
	        }
	        return days;
	    }

	    /**
		 * 获取两个日期相减得到的天数格式yyyyMMddHHmmss
		 *
		 * @param beginDate
		 *            开始日期
		 * @param endDate
		 *            结束日期
		 * @return
		 * @throws Exception
		 */
		public static int getDistanceDays2(String beginDate, String endDate) throws Exception {
			SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
			Calendar calendar1 = Calendar.getInstance();
			Calendar calendar2 = Calendar.getInstance();

			calendar1.setTime(format.parse(beginDate));
			calendar2.setTime(format.parse(endDate));

			return (int) ((calendar2.getTimeInMillis() - calendar1.getTimeInMillis()) / 1000 / 60 / 60 / 24);// 结果
		}
		 /**
		 * 获取月周期数
		 *
		 * @param date
		 *
		 * @return
		 * @throws Exception
		 */
		public static int getMonthWeek (String date) throws Exception {
		    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
		    Date s = sdf.parse(date);
		    Calendar ca = Calendar.getInstance();
		    ca.setTime(s);
		    ca.setFirstDayOfWeek(Calendar.MONDAY);
		    return ca.getActualMaximum(Calendar.WEEK_OF_MONTH);
		};
		public static boolean isValidDate(String str,String parttern) {
		      boolean convertSuccess=true;
		// 指定日期格式为四位年/两位月份/两位日期，注意yyyy/MM/dd区分大小写；
		       SimpleDateFormat format = new SimpleDateFormat(parttern);
		       try {
		// 设置lenient为false. 否则SimpleDateFormat会比较宽松地验证日期，比如2007/02/29会被接受，并转换成2007/03/01
		          format.setLenient(false);
		          format.parse(str);
		       } catch (ParseException e) {
		          // e.printStackTrace();
		// 如果throw java.text.ParseException或者NullPointerException，就说明格式不对
		           convertSuccess=false;
		       }
		       return convertSuccess;
		}
}


